// 导入 RCSP 相关类
const { CmdCustom, ParamBase } = require('../../jl_lib/jl-rcsp/jl_rcsp_watch_1.1.0');
const { RCSPManager } = require('../../lib/rcsp-impl/rcsp');

Page({
  data: {
    did: '',
    users: [],  
    needsRefresh: false,
    isLoading: false, // 全局加载状态（用于删除操作）
    loadingText: '',
    lastFingerprintId: 0, // 用于指纹ID自增
    currentFingerprintId: 0, // 当前正在添加的指纹ID
    isQueryingFingerprints: false, // 指纹查询状态
    isAddingFingerprint: false, // 添加指纹状态标记
    
    // 添加指纹弹窗相关
    showAddModal: false,
    addStatus: 'adding', // adding | success | error
    addProgress: 0, // 当前步骤 (0-5)
    addProgressPercent: 0, // 进度百分比
    addProgressText: '准备录入...', // 进度文字
    addErrorMsg: '', // 错误信息
    
    // 查询指纹相关
    pendingQueryResolve: null, // 待处理的查询Promise
    pendingQueryReject: null,
    fingerprintAddTimeoutId: null,
    
    // 缓存的指纹列表
    cachedFingerprintList: [],
    lastQueryTime: 0
  },

  // 原始数据监听器
  originalOnReceiveData: null,
  
  // 🎯 删除专用监听器相关
  pendingDeleteResolve: null,
  pendingDeleteReject: null,
  deletingFingerprintId: 0,
  
  // 🎯 当前RCSP命令引用（用于取消重发）
  currentRcspCommand: null,
  currentRcspDevice: null,
  
  // 🎯 当前添加指纹命令引用（用于完成时移除）
  currentAddCommand: null,
  currentAddDevice: null,
  
  // 🎯 所有活跃的RCSP命令队列（用于页面卸载时清理）
  activeRcspCommands: [],
  
  // 🎯 命令回调映射表（用于主动触发回调）
  _commandCallbacks: null,
  
  // 🎯 最后一次成功处理查询响应的时间戳（防止重复处理查询）
  lastQueryResponseTime: 0,
  
  // 🎯 已处理的添加指纹步骤记录（防止重复处理相同步骤）
  processedAddSteps: new Set(), // 存储已处理的步骤号，如：1, 2, 3, 4, 5

  onShow: function() {
    // ✅ 取消自动刷新，使用缓存数据
    if (this.data.needsRefresh) {
      console.log('⚠️ 检测到刷新标记，但已禁用自动刷新');
      this.setData({ needsRefresh: false });
    }
  },

  onLoad: function(options) {
    console.log('📱 [lockControlUsers] 页面加载，参数:', options);
    
    // 🎯 初始化命令回调映射表
    if (!this._commandCallbacks) {
      this._commandCallbacks = new Map();
      console.log('✅ 初始化命令回调映射表');
    }
    
    if (options.did) {
      this.setData({
        did: options.did
      });
      console.log('设置设备ID:', options.did);
      // ✅ 页面加载时查询指纹列表（进入页面时唯一的查询）
      this.loadFingerprintUsers();
    }
  },

  onUnload: function() {
    console.log('📱 [lockControlUsers] 页面卸载');
    
    // 🎯 第一步：如果正在添加指纹，先发送取消命令
    if (this.data.isAddingFingerprint && this.data.addStatus === 'adding') {
      console.log('⚠️ 页面卸载时检测到正在添加指纹，发送取消命令');
      try {
        this.sendCancelAddFingerprintCommand();
      } catch (err) {
        console.error('❌ 发送取消命令失败:', err);
      }
    }
    
    // 🎯 第二步：强制清空 RCSP SDK 的发送队列（关键！）
    console.log('🧹 页面卸载时强制清空 RCSP SDK 发送队列');
    this.forceCleanRcspQueue();
    
    // 🎯 第三步：清理所有活跃的RCSP命令
    console.log('🧹 页面卸载时清理所有活跃的RCSP命令，共', this.activeRcspCommands.length, '个');
    this.cleanupAllRcspCommands();
    
    // 🎯 第四步：清理命令回调映射表
    if (this._commandCallbacks) {
      this._commandCallbacks.clear();
      console.log('✅ 已清理命令回调映射表');
    }
    
    // 清理原始数据监听器
    this.cleanupUnifiedRawDataListener();
    // 清理查询pending状态
    this.clearPendingQuery();
    // 清理删除监听器
    this.cleanupDeleteRawDataListener();
    // 重置时间戳
    this.lastQueryResponseTime = 0;
    // 清空已处理步骤记录
    this.processedAddSteps.clear();
  },


  // ========== 设备连接相关 ==========
  
  // 检查设备连接状态
  checkDeviceConnection: function() {
    try {
      const curId = RCSPManager.getCurrentRcspOperateWrapper()?.deviceId || '';
      const isConnected = curId !== '';
      
      console.log('🔍 检查设备连接状态:', {
        currentRcspId: curId,
        isConnected: isConnected
      });
      
      if (!isConnected) {
        wx.showToast({
          title: '设备未连接，请先连接设备',
          icon: 'none'
        });
      }
      
      return isConnected;
    } catch (error) {
      console.error('检查设备连接失败:', error);
      wx.showToast({
        title: '检查设备连接失败',
        icon: 'none'
      });
      return false;
    }
  },

  // 获取RCSP操作实例
  getRcspWrapper: function() {
    try {
      const rcspWrapperContainer = RCSPManager.getCurrentRcspOperateWrapper();
      if (!rcspWrapperContainer || !rcspWrapperContainer.wrapper) {
        throw new Error('RCSP包装器不可用');
      }
      return rcspWrapperContainer;
    } catch (error) {
      console.error('获取RCSP包装器失败:', error);
      throw error;
    }
  },

  // ========== 查询指纹列表 ==========
  
  // 🎯 强制刷新指纹列表（忽略缓存）
  forceRefreshFingerprints: function() {
    console.log('🔄 强制刷新指纹列表（忽略缓存）');
    // 清空缓存时间戳，强制重新查询
    const cacheKey = `fingerprint_cache_${this.data.deviceId}`;
    wx.removeStorageSync(cacheKey); // 清除本地存储缓存
    this.setData({
      lastQueryTime: 0
    });
    this.loadFingerprintUsers();
  },
  
  // 加载指纹用户列表
  loadFingerprintUsers: function() {
    if (!this.checkDeviceConnection()) {
      return;
    }

    // 🎯 优先使用缓存（30秒内有效）
    const now = Date.now();
    // 🔥 从本地存储读取缓存（页面卸载后也能保留）
    const cacheKey = `fingerprint_cache_${this.data.deviceId}`;
    const cached = wx.getStorageSync(cacheKey);
    const lastQueryTime = cached ? cached.timestamp : 0;
    const cachedList = cached ? cached.list : null;
    const cacheAge = now - lastQueryTime;
    const CACHE_VALID_TIME = 30 * 1000; // 30秒缓存有效期
    
    if (cacheAge < CACHE_VALID_TIME && cachedList && cachedList.length > 0) {
      console.log(`📦 使用缓存的指纹列表 (${Math.floor(cacheAge/1000)}秒前):`, cachedList);
      const users = this.parseFingerprintUsers(cachedList);
      this.setData({ 
        users: users,
        cachedFingerprintList: cachedList,
        lastQueryTime: lastQueryTime,
        isQueryingFingerprints: false
      });
      return;
    }

    // 设置指纹查询状态为true
    this.setData({ 
      isQueryingFingerprints: true 
    });
    
    console.log('🔄 缓存已过期或不存在，重新查询设备');
    
    // 发送查询指纹命令
    this.sendFingerprintQueryCommand()
      .then(occupiedIds => {
        console.log('✅ 查询指纹列表成功:', occupiedIds);
        
        // 🎯 缓存查询结果（同时保存到本地存储）
        const now = Date.now();
        const cacheKey = `fingerprint_cache_${this.data.deviceId}`;
        wx.setStorageSync(cacheKey, {
          list: occupiedIds,
          timestamp: now
        });
        
        this.setData({
          cachedFingerprintList: occupiedIds,
          lastQueryTime: now
        });
        console.log('💾 缓存指纹列表到本地存储:', occupiedIds);
        
        const users = this.parseFingerprintUsers(occupiedIds);
        
        this.setData({ 
          users: users,
          isQueryingFingerprints: false
        });
      })
      .catch(error => {
        console.error('❌ 查询指纹列表失败:', error);
        
        // 🎯 失败时，从本地存储读取旧缓存
        const cacheKey = `fingerprint_cache_${this.data.deviceId}`;
        const cached = wx.getStorageSync(cacheKey);
        const oldCacheList = cached ? cached.list : null;
        
        if (oldCacheList && oldCacheList.length > 0) {
          console.log('⚠️ 查询失败，继续使用本地存储的旧缓存:', oldCacheList);
          const users = this.parseFingerprintUsers(oldCacheList);
          this.setData({ 
            users: users,
            cachedFingerprintList: oldCacheList,
            lastQueryTime: cached.timestamp,
            isQueryingFingerprints: false
          });
        } else {
          // 没有缓存才显示空列表
          console.log('⚠️ 查询失败且无缓存，显示空列表');
          this.setData({ 
            users: [],
            isQueryingFingerprints: false
          });
          
          wx.showToast({
            title: '查询指纹列表失败',
            icon: 'none'
          });
        }
      });
  },

  // 发送查询指纹命令
  sendFingerprintQueryCommand: function() {
    return new Promise((resolve, reject) => {
      try {
        if (!this.checkDeviceConnection()) {
          reject(new Error('设备未连接'));
          return;
        }

        const rcspWrapper = this.getRcspWrapper();
        const actualWrapper = rcspWrapper.wrapper;
        const rcspOpImpl = actualWrapper._rcspOpImpl;
        
        if (!rcspOpImpl) {
          reject(new Error('RCSP操作实例不可用'));
          return;
        }

        const currentDevice = rcspOpImpl.getUsingDevice();
        if (!currentDevice) {
          reject(new Error('当前没有使用的设备'));
          return;
        }

        // 🎯 设置pending状态用于接收查询响应
        this.pendingQueryResolve = resolve;
        this.pendingQueryReject = reject;
        
        // 🎯 设置统一的原始数据监听器
        this.setupUnifiedRawDataListener();

        // 创建查询参数类
        class QueryParam extends ParamBase {
          constructor() {
            super();
            this.basePayload = new Uint8Array([0x01]); // 0x01 = 查询
          }
          
          toData() {
            return this.basePayload;
          }
          
          parseData(data) {
            this.basePayload = data;
            return data.length;
          }
        }

        const param = new QueryParam();
        const command = new CmdCustom(param);
        command.setOpCode(0x5A);
        
        // 🎯 保存命令引用，用于后续取消重发
        this.currentRcspCommand = command;
        this.currentRcspDevice = currentDevice;
        
        // 🎯 跟踪命令
        this.trackRcspCommand(currentDevice, command);
        
        // 命令回调处理
        const commandCallback = {
          onCmdResponse: (device, cmd) => {
            console.log('✅ 收到查询指纹RCSP响应（但原始数据监听器应该已处理）');
            // 🎯 移除已完成的命令
            this.removeRcspCommand(command);
            
            // 原始数据监听器会处理，这里作为备用
            if (this.pendingQueryResolve) {
              console.log('⚠️ 原始数据监听器未处理，使用RCSP响应作为备用');
              const response = cmd.getResponse();
              if (response) {
                const payload = response.getPayload();
                if (payload && payload.length >= 2) {
                  const occupiedIds = this.parseRcspPayload(payload);
                  this.pendingQueryResolve(occupiedIds);
                  this.clearPendingQuery();
                } else {
                  // 🎯 payload不完整也应该reject，保护缓存
                  console.log('⚠️ payload数据不完整，触发错误处理（保护缓存）');
                  this.pendingQueryReject(new Error('payload数据不完整'));
                  this.clearPendingQuery();
                }
              } else {
                this.pendingQueryReject(new Error('无响应数据'));
                this.clearPendingQuery();
              }
            }
          },
          onError: (device, code, message) => {
            console.error('❌ 查询指纹RCSP命令错误:', code, message);
            // 🎯 移除已完成的命令
            this.removeRcspCommand(command);
            
            // 💡 如果原始数据监听器已经处理了，忽略这个错误
            if (!this.pendingQueryResolve) {
              console.log('✅ 原始数据监听器已处理，忽略RCSP超时错误');
              return;
            }
            
            // 🎯 改为reject而不是resolve，这样才能保护旧缓存
            setTimeout(() => {
              if (this.pendingQueryReject) {
                console.log('⚠️ RCSP命令超时，触发错误处理（保护缓存）');
                this.pendingQueryReject(new Error('RCSP命令超时'));
                this.clearPendingQuery();
              }
            }, 300);
          }
        };

        // 🎯 保存命令回调到映射表
        this._commandCallbacks.set(command, commandCallback);
        console.log('📌 已保存查询命令回调到映射表');

        // 发送RCSP命令（缩短超时时间到1秒，快速响应）
        rcspOpImpl.sendRCSPCommand(
          currentDevice,
          command,
          1000, // ✅ 改为1000ms，因为实际响应很快（500ms内）
          commandCallback
        );

        console.log('📤 已发送查询指纹命令，等待原始数据响应');

        // ✅ 总超时时间稍微长一点，给原始数据监听器足够时间
        setTimeout(() => {
          if (this.pendingQueryReject) {
            console.log('⏰ 查询指纹总超时，触发错误处理（保护缓存）');
            this.pendingQueryReject(new Error('查询总超时'));
            this.clearPendingQuery();
          }
        }, 2500); // 2.5秒总超时

      } catch (error) {
        console.error('发送查询指纹命令失败:', error);
        this.clearPendingQuery();
        reject(error);
      }
    });
  },

  // 解析指纹用户数据
  parseFingerprintUsers: function(occupiedIds) {
    try {
      if (!occupiedIds || occupiedIds.length === 0) {
        return [];
      }

      const users = [];
      // 读取保存的指纹用户名称
      const savedNames = wx.getStorageSync('fingerprintUserNames') || {};

      occupiedIds.forEach(fingerId => {
        const fingerIdStr = `F${String(fingerId).padStart(3, '0')}`;
        const savedName = savedNames[fingerIdStr];
        
        users.push({
          id: fingerId,
          fingerId: fingerIdStr,
          name: savedName || `指纹用户${fingerId}`,
          type: '指纹',
          icon: '/assets/img/fingerprint_icon.png'
        });
      });

      return users;
    } catch (error) {
      console.error('解析指纹用户数据失败:', error);
      return [];
    }
  },

  // 查找空闲指纹ID
  findAvailableFingerprintId: function(occupiedIds) {
    for (let i = 1; i <= 5; i++) {
      if (!occupiedIds.includes(i)) {
        return i;
      }
    }
    return null; // 已满
  },

  // ========== 唤醒指令 ==========
  
  // 发送唤醒指令（在添加/删除前调用，不等待响应）
  sendWakeUpCommand: function() {
    return new Promise((resolve, reject) => {
      try {
        if (!this.checkDeviceConnection()) {
          reject(new Error('设备未连接'));
          return;
        }

        const rcspWrapper = this.getRcspWrapper();
        const actualWrapper = rcspWrapper.wrapper;
        const rcspOpImpl = actualWrapper._rcspOpImpl;
        
        if (!rcspOpImpl) {
          reject(new Error('RCSP操作实例不可用'));
          return;
        }
  
        const currentDevice = rcspOpImpl.getUsingDevice();
        if (!currentDevice) {
          reject(new Error('当前没有使用的设备'));
          return;
        }

        // 创建唤醒参数类
        class WakeUpParam extends ParamBase {
          constructor() {
            super();
            this.basePayload = new Uint8Array([0xFF]); // 0xFF = 唤醒
          }
          
          toData() {
            return this.basePayload;
          }
          
          parseData(data) {
            this.basePayload = data;
            return data.length;
          }
        }

        const param = new WakeUpParam();
        const command = new CmdCustom(param);
        command.setOpCode(0x5A);
        
        // 唤醒指令不需要等待响应，发送即完成
        const commandCallback = {
          onCmdResponse: (device, command) => {
            console.log('💤 唤醒指令响应（可忽略）');
          },
          onError: (device, code, message) => {
            console.log('💤 唤醒指令错误（可忽略）:', code, message);
          }
        };

        rcspOpImpl.sendRCSPCommand(
          currentDevice,
          command,
          3000,
          commandCallback
        );

        console.log('📤 已发送唤醒指令 (0xFF)，不等待响应');
        
        // 发送后立即resolve，不等待设备响应
        resolve();

      } catch (error) {
        console.error('❌ 发送唤醒指令异常:', error);
        // 异常时也resolve，不阻断流程
        resolve();
      }
    });
  },

  // 🎯 发送取消添加指纹命令（OpCode 0x04）
  sendCancelAddFingerprintCommand: function() {
    try {
      if (!this.checkDeviceConnection()) {
        return;
      }

      const rcspWrapper = this.getRcspWrapper();
      const actualWrapper = rcspWrapper.wrapper;
      const rcspOpImpl = actualWrapper._rcspOpImpl;
      
      if (!rcspOpImpl) {
        console.error('RCSP操作实例不可用');
        return;
      }

      const currentDevice = rcspOpImpl.getUsingDevice();
      if (!currentDevice) {
        console.error('当前没有使用的设备');
        return;
      }

      // 创建取消添加参数类
      class CancelAddParam extends ParamBase {
        constructor() {
          super();
          this.basePayload = new Uint8Array([0x04]); // 0x04 = 取消添加指纹
        }
        
        toData() {
          return this.basePayload;
        }
        
        parseData(data) {
          this.basePayload = data;
          return data.length;
        }
      }

      const param = new CancelAddParam();
      const command = new CmdCustom(param);
      command.setOpCode(0x5A);
      
      // 取消添加指令不需要等待响应，发送即完成
      const commandCallback = {
        onCmdResponse: (device, command) => {
          console.log('✅ 取消添加指纹指令响应（可忽略）');
        },
        onError: (device, code, message) => {
          console.log('⚠️ 取消添加指纹指令错误（可忽略）:', code, message);
        }
      };

      rcspOpImpl.sendRCSPCommand(
        currentDevice,
        command,
        3000,
        commandCallback
      );

      console.log('📤 已发送取消添加指纹指令 (0x04)，不等待响应');

    } catch (error) {
      console.error('❌ 发送取消添加指纹指令异常:', error);
      // 异常不影响流程，继续
    }
  },

  // ========== 添加指纹流程 ==========
  
  // 添加指纹（主入口）
  addFingerprint: function() {
    console.log('🎯 [addFingerprint] 用户点击添加指纹');
    
    if (!this.checkDeviceConnection()) {
      return;
    }

    // 显示确认对话框，避免意外触发
    wx.showModal({
      title: '添加指纹',
      content: '确定要开始录入新的指纹吗？\n请确保手指清洁，并准备好进行5步录入操作。',
      confirmText: '开始录入',
      cancelText: '取消',
      success: (res) => {
        if (res.confirm) {
          console.log('🎯 用户确认开始添加指纹流程');
          this.startAddFingerprintProcess();
        } else {
          console.log('❌ 用户取消添加指纹');
        }
      }
    });
  },

  // 开始添加指纹流程
  startAddFingerprintProcess: function() {
    console.log('🚀 开始添加指纹流程');
    
    if (!this.checkDeviceConnection()) {
      return;
    }

    // ✅ 直接使用缓存的指纹列表，不再查询
    console.log('📋 直接使用缓存的指纹列表:', this.data.cachedFingerprintList);
    
    // 检查缓存是否存在
    if (!this.data.cachedFingerprintList) {
      console.log('⚠️ 缓存未初始化，使用空数组');
      this.setData({
        cachedFingerprintList: []
      });
    }
    
    // 直接继续添加流程
    this.proceedWithAddFingerprint(this.data.cachedFingerprintList);
  },

  // 继续添加指纹流程
  proceedWithAddFingerprint: function(occupiedIds) {
    console.log('🔄 继续添加指纹流程，已占用ID:', occupiedIds);
    
    // 🧹 步骤1: 清理之前查询的 pending 状态和监听器
    console.log('🧹 清理之前的查询状态...');
    if (this.pendingQueryResolve) {
      console.log('⚠️ 发现未完成的查询，强制清理');
      this.clearPendingQuery();
    }
    
    // 步骤2: 找空闲ID
    const availableId = this.findAvailableFingerprintId(occupiedIds);
    
    if (availableId === null) {
      wx.showToast({
        title: '指纹已满（最多5个）',
        icon: 'none'
      });
      return;
    }
    
    console.log('✅ 分配指纹ID:', availableId);
    
    // 步骤3: 设置添加状态标记
    this.setData({
      isAddingFingerprint: true
    });
    console.log('🏷️ 设置添加指纹状态标记');
    
    // 步骤4: 打开弹窗（显示"正在唤醒设备..."）
    this.openAddModal(availableId);
    this.setData({
      addProgressText: '正在唤醒设备...'
    });
    
    // 步骤5: 发送唤醒指令，1秒后再发送添加命令
    console.log('⏰ 发送唤醒指令...');
    this.sendWakeUpCommand()
      .then(() => {
        console.log('⏳ 等待1秒后发送添加命令...');
        return new Promise(resolve => setTimeout(resolve, 1000));
      })
      .then(() => {
        console.log('✅ 唤醒完成，准备发送添加命令');
        
        // 设置统一的原始数据监听器（只处理添加响应）
        this.setupUnifiedRawDataListener();
        
        // 更新进度文字
        this.setData({
          addProgressText: '准备录入...'
        });
        
        // 发送添加命令
        this.sendFingerprintAddCommand(availableId);
      })
      .catch(error => {
        console.error('❌ 唤醒流程失败:', error);
        this.handleAddError('设备唤醒失败');
      });
  },

  // 打开添加弹窗
  openAddModal: function(fingerprintId) {
    // 🎯 清空已处理步骤记录，开始新的添加流程
    this.processedAddSteps.clear();
    console.log('🧹 清空已处理步骤记录，开始新的添加流程');
    
    this.setData({
      currentFingerprintId: fingerprintId,
      showAddModal: true,
      addStatus: 'adding',
      addProgress: 0,
      addProgressPercent: 0,
      addProgressText: '准备录入...',
      addErrorMsg: ''
    });
  },

  // 关闭添加弹窗
  closeAddModal: function() {
    // 🎯 如果正在添加指纹（未完成），发送取消命令
    if (this.data.isAddingFingerprint && this.data.addStatus === 'adding') {
      console.log('⚠️ 关闭弹窗时检测到正在添加指纹，发送取消命令');
      this.sendCancelAddFingerprintCommand();
      
      // 🎯 强制清空 RCSP 队列，防止取消命令也被重发
      console.log('🧹 关闭弹窗时强制清空 RCSP SDK 发送队列');
      this.forceCleanRcspQueue();
    }
    
    // 清理监听器
    this.cleanupUnifiedRawDataListener();
    
    // 🎯 清空已处理步骤记录
    this.processedAddSteps.clear();
    console.log('🧹 关闭弹窗，清空已处理步骤记录');
    
    this.setData({
      showAddModal: false,
      addStatus: 'adding',
      addProgress: 0,
      addProgressPercent: 0,
      currentFingerprintId: 0,
      isAddingFingerprint: false // 清除添加状态标记
    });
  },

  // 重试添加指纹
  retryAddFingerprint: function() {
    console.log('🔄 重试添加指纹');
    this.closeAddModal();
    
    // 延迟一下再重新开始（重试时不需要再次确认）
    setTimeout(() => {
      this.startAddFingerprintProcess();
    }, 300);
  },

  // 发送添加指纹命令
  sendFingerprintAddCommand: function(fingerprintId) {
    try {
      const rcspWrapper = this.getRcspWrapper();
      const actualWrapper = rcspWrapper.wrapper;
      const rcspOpImpl = actualWrapper._rcspOpImpl;
      
      if (!rcspOpImpl) {
        console.error('RCSP操作实例不可用');
        return;
      }

      const currentDevice = rcspOpImpl.getUsingDevice();
      if (!currentDevice) {
        console.error('当前没有使用的设备');
        return;
      }

      // 创建添加参数类
      class AddParam extends ParamBase {
        constructor(fingerprintId) {
          super();
          this.basePayload = new Uint8Array([0x02, fingerprintId]);
          // 0x02 = 添加操作, fingerprintId = 标号(1-5)
        }
        
        toData() {
          return this.basePayload;
        }
        
        parseData(data) {
          this.basePayload = data;
          return data.length;
        }
      }

      const param = new AddParam(fingerprintId);
      const command = new CmdCustom(param);
      command.setOpCode(0x5A);
      
      // 🎯 保存添加命令引用（用于完成时移除）
      this.currentAddCommand = command;
      this.currentAddDevice = currentDevice;
      
      // 🎯 跟踪命令
      this.trackRcspCommand(currentDevice, command);
      
      // 注意：添加命令的响应通过原始数据监听器处理
      const commandCallback = {
        onCmdResponse: (device, cmd) => {
          console.log('✅ 添加指纹命令已发送');
          // 🎯 添加命令需要等待5步完成，暂不移除
          // 在 handleAddFingerprintStep 中步骤5完成时移除
        },
        onError: (device, code, message) => {
          console.error('❌ 添加指纹命令发送失败:', code, message);
          // 🎯 移除失败的命令
          this.removeRcspCommand(command);
          this.handleAddError('命令发送失败');
        }
      };

      // 🎯 保存命令回调到映射表
      this._commandCallbacks.set(command, commandCallback);
      console.log('📌 已保存添加命令回调到映射表');

      rcspOpImpl.sendRCSPCommand(
        currentDevice,
        command,
        8000, // 🎯 8秒超时（防止页面卸载后长时间重发）
        commandCallback
      );

      console.log(`📤 已发送添加指纹命令，标号: ${fingerprintId}`);

    } catch (error) {
      console.error('❌ 发送添加命令异常:', error);
      this.handleAddError('发送命令异常');
    }
  },

  // 🎯 设置统一的原始数据监听器（同时处理查询和添加）
  setupUnifiedRawDataListener: function() {
    console.log('🎧 设置统一原始数据监听器');
    
    // 保存原始监听器
    if (!this.originalOnReceiveData && RCSPManager.onReceiveData) {
      this.originalOnReceiveData = RCSPManager.onReceiveData.bind(RCSPManager);
      
      // 重写监听器
      RCSPManager.onReceiveData = (deviceId, data) => {
        // 🎯 先检查是否是指纹数据，如果是就优先处理并构造假响应给RCSP
        try {
          const hexString = this.arrayBufferToHex(data);
          console.log('📡 拦截到原始数据:', hexString);
          
          // 检查是否是RCSP指纹响应：fedcbac05a...
          if (hexString.toLowerCase().includes('fedcbac05a')) {
            // 提取10字节数据，判断是查询还是添加
            const pattern = /fedcbac05a([0-9a-f]+)ef/i;
            const match = hexString.match(pattern);
            
            if (match && match[1] && match[1].length >= 26) {
              const targetData = match[1].substring(6, 26); // 跳过前3字节，取10字节
              const opCode = parseInt(targetData.substring(0, 2), 16);
              
              if (opCode === 0x01) {
                // 查询指纹响应
                if (this.data.isAddingFingerprint) {
                  console.log('⚠️ 添加指纹过程中，忽略查询响应');
                  // 忽略查询响应，仍调用原始处理
                } else {
                console.log('🎯 发现查询指纹响应，优先处理并构造假响应');
                
                // 🔥 关键1：先构造假响应（此时activeRcspCommands还有命令，可以提取SN）
                console.log('🎭 构造假响应，OpCode=0x90，阻止RCSP重发');
                const fakeResponse = this.createFakeRcspResponse(0x90);
                
                // 🔥 关键2：再解析真实数据（这会触发回调并清理命令）
                this.parseQueryRawData(hexString);
                
                // 🔥 关键3：最后发送假响应给SDK
                if (fakeResponse && this.originalOnReceiveData) {
                  this.originalOnReceiveData(deviceId, fakeResponse);
                }
                
                console.log('✅ 查询数据已处理，假响应已发送给RCSP');
                return;
                }
              } else if (opCode === 0x02) {
                // 添加指纹响应
                console.log('🎯 发现添加指纹响应，优先处理并构造假响应');
                
                // 🔥 关键1：先构造假响应（此时activeRcspCommands还有命令，可以提取SN）
                console.log('🎭 构造假响应，OpCode=0x90，阻止RCSP重发');
                const fakeResponse = this.createFakeRcspResponse(0x90);
                
                // 🔥 关键2：再解析真实数据（这会触发回调并清理命令）
                this.parseAddRawData(hexString);
                
                // 🔥 关键3：最后发送假响应给SDK
                if (fakeResponse && this.originalOnReceiveData) {
                  this.originalOnReceiveData(deviceId, fakeResponse);
                }
                
                console.log('✅ 添加数据已处理，假响应已发送给RCSP');
                return;
              } else {
                console.log('⚠️ 未知OpCode:', '0x' + opCode.toString(16));
              }
            }
          }
        } catch (error) {
          console.error('❌ 处理指纹原始数据失败:', error);
        }
        
        // 如果不是指纹数据，或者处理失败，调用原始处理器
        if (this.originalOnReceiveData) {
          this.originalOnReceiveData(deviceId, data);
        }
      };
      
      console.log('✅ 统一原始数据监听器已设置');
    }
  },
  
  // 🎭 构造假的RCSP响应（OpCode=0x90，让SDK认为收到了CmdCustom的响应）
  createFakeRcspResponse: function(opCode) {
    try {
      console.log('🎭 开始构造假RCSP响应...');
      
      // RCSP 数据包格式：FE DC BA C0 [长度2字节] [属性1字节] [OpCode1字节] [SN2字节] [负载...] EF
      // 属性字节：bit7=0(响应), bit0=0(不需要回复)
      const attr = 0x00; // 响应包，不需要回复
      
      // 🔥 关键：从活跃命令队列中获取SN（必须匹配才能停止重发）
      let sn = 0x0001; // 默认 SN
      if (this.activeRcspCommands && this.activeRcspCommands.length > 0) {
        console.log('🔍 当前活跃命令数:', this.activeRcspCommands.length);
        console.log('🔍 正在查找OpCode:', opCode, '类型:', typeof opCode);
        
        // 打印所有活跃命令的OpCode
        this.activeRcspCommands.forEach((item, index) => {
          if (item.command) {
            console.log(`  命令[${index}] OpCode:`, item.command._opCode, '类型:', typeof item.command._opCode, 'SN:', item.command._sn);
          }
        });
        
        // 找到OpCode匹配的命令
        const matchedCommand = this.activeRcspCommands.find(item => {
          return item.command && item.command._opCode === opCode;
        });
        
        if (matchedCommand && matchedCommand.command._sn !== undefined) {
          sn = matchedCommand.command._sn;
          console.log('✅ 从活跃命令中提取SN:', '0x' + sn.toString(16).toUpperCase());
        } else {
          console.log('⚠️ 未找到匹配的命令，使用默认SN');
        }
      } else {
        console.log('⚠️ 无活跃命令，使用默认SN');
      }
      
      // 构造一个简单的成功响应：负载=[0x00]（表示成功）
      const payload = new Uint8Array([0x00]);
      
      // 计算总长度：属性(1) + OpCode(1) + SN(2) + 负载长度
      const contentLength = 1 + 1 + 2 + payload.length;
      
      // 构造完整数据包
      const packet = new Uint8Array(4 + 2 + contentLength + 1);
      let offset = 0;
      
      // 头部：FE DC BA C0
      packet[offset++] = 0xFE;
      packet[offset++] = 0xDC;
      packet[offset++] = 0xBA;
      packet[offset++] = 0xC0;
      
      // 长度（大端序）
      packet[offset++] = (contentLength >> 8) & 0xFF;
      packet[offset++] = contentLength & 0xFF;
      
      // 属性
      packet[offset++] = attr;
      
      // OpCode
      packet[offset++] = opCode;
      
      // SN（大端序）
      packet[offset++] = (sn >> 8) & 0xFF;
      packet[offset++] = sn & 0xFF;
      
      // 负载
      packet.set(payload, offset);
      offset += payload.length;
      
      // 结束符：EF
      packet[offset++] = 0xEF;
      
      console.log('✅ 假响应构造完成:', this.arrayBufferToHex(packet.buffer));
      console.log('   OpCode:', '0x' + opCode.toString(16).toUpperCase());
      console.log('   SN:', '0x' + sn.toString(16).toUpperCase());
      
      return packet.buffer;
      
    } catch (error) {
      console.error('❌ 构造假响应失败:', error);
      return null;
    }
  },

  // 🧹 清理统一监听器
  cleanupUnifiedRawDataListener: function() {
    if (this.originalOnReceiveData && RCSPManager) {
      RCSPManager.onReceiveData = this.originalOnReceiveData;
      this.originalOnReceiveData = null;
      console.log('✅ 统一原始数据监听器已清理');
    }
  },

  // 🎯 设置删除专用的原始数据监听器
  setupDeleteRawDataListener: function(fingerprintId, resolve, reject) {
    console.log('🎧 设置删除专用原始数据监听器，指纹ID:', fingerprintId);
    
    this.pendingDeleteResolve = resolve;
    this.pendingDeleteReject = reject;
    this.deletingFingerprintId = fingerprintId;
    
    // 保存原始监听器
    if (!this.originalOnReceiveData && RCSPManager.onReceiveData) {
      this.originalOnReceiveData = RCSPManager.onReceiveData.bind(RCSPManager);
      
      // 重写监听器
      RCSPManager.onReceiveData = (deviceId, data) => {
        // 🎯 先检查是否是删除数据，如果是就优先处理并构造假响应给RCSP
        try {
          const hexString = this.arrayBufferToHex(data);
          console.log('📡 [删除监听] 拦截到原始数据:', hexString);
          
          // 检查是否是删除响应：fedcbac05a...03xx...ef (03是删除OpCode，xx是标号1-5)
          if (hexString.toLowerCase().includes('fedcbac05a')) {
            // 提取数据，检查OpCode是否为0x03（删除）
            const pattern = /fedcbac05a([0-9a-f]+)ef/i;
            const match = hexString.match(pattern);
            
            if (match && match[1] && match[1].length >= 26) {
              const targetData = match[1].substring(6, 26); // 跳过前3字节
              const opCode = parseInt(targetData.substring(0, 2), 16);
              
              // 只处理OpCode=0x03的删除响应
              if (opCode === 0x03) {
                console.log('🎯 发现删除指纹响应，优先处理并构造假响应');
                
                // 🔥 关键1：先构造假响应（此时activeRcspCommands还有命令，可以提取SN）
                console.log('🎭 构造假响应，OpCode=0x90，阻止RCSP重发');
                const fakeResponse = this.createFakeRcspResponse(0x90);
                
                // 🔥 关键2：再解析真实数据（这会触发回调并清理命令）
                this.parseDeleteRawData(hexString);
                
                // 🔥 关键3：最后发送假响应给SDK
                if (fakeResponse && this.originalOnReceiveData) {
                  this.originalOnReceiveData(deviceId, fakeResponse);
                }
                
                console.log('✅ 删除数据已处理，假响应已发送给RCSP');
                return;
              }
            }
          }
        } catch (error) {
          console.error('❌ 处理删除原始数据失败:', error);
        }
        
        // 如果不是删除数据，或者处理失败，调用原始处理器
        if (this.originalOnReceiveData) {
          this.originalOnReceiveData(deviceId, data);
        }
      };
      
      console.log('✅ 删除专用原始数据监听器已设置');
    }
  },

  // 🧹 清理删除监听器
  cleanupDeleteRawDataListener: function() {
    console.log('🧹 清理删除监听器');
    
    if (this.originalOnReceiveData && RCSPManager) {
      RCSPManager.onReceiveData = this.originalOnReceiveData;
      this.originalOnReceiveData = null;
    }
    
    this.pendingDeleteResolve = null;
    this.pendingDeleteReject = null;
    this.deletingFingerprintId = 0;
    
    console.log('✅ 删除监听器已清理');
  },

  // 🎯 解析删除指纹的原始数据
  parseDeleteRawData: function(hexString) {
    try {
      console.log('━━━━━ 删除指纹原始数据解析 ━━━━━');
      console.log('完整数据:', hexString);
      
      // 查找删除响应模式：fedcbac05a...ef
      const pattern = /fedcbac05a([0-9a-f]+)ef/i;
      const match = hexString.match(pattern);
      
      if (!match || !match[1]) {
        console.log('❌ 未匹配到删除响应模式');
        return;
      }
      
      const allData = match[1];
      console.log('🎯 提取到所有中间数据:', allData);
      
      // 跳过前3字节的底层协议，提取后面的10字节数据
      if (allData.length >= 26) {
        const targetData = allData.substring(6, 26);
        console.log('📊 目标10字节数据:', targetData);
        
        // 转换为字节数组
        const bytes = [];
        for (let i = 0; i < targetData.length; i += 2) {
          bytes.push(parseInt(targetData.substring(i, i + 2), 16));
        }
        
        console.log('字节数组:', bytes.map(b => '0x' + b.toString(16).padStart(2, '0')).join(' '));
        
        // 解析删除响应：OpCode(0x03) + 标号(1-5) + 确认码(0xff=成功)
        const opCode = bytes[0];
        const responseId = bytes[1];
        const confirmCode = bytes[2];
        
        console.log('删除响应详情:', {
          opCode: '0x' + opCode.toString(16).padStart(2, '0'),
          标号: responseId,
          确认码: '0x' + confirmCode.toString(16).padStart(2, '0')
        });
        
        // 验证OpCode
        if (opCode !== 0x03) {
          console.log('❌ OpCode不匹配，期望0x03');
          return;
        }
        
        // 验证标号
        if (responseId !== this.deletingFingerprintId) {
          console.log('❌ 标号不匹配，期望:', this.deletingFingerprintId, '实际:', responseId);
          return;
        }
        
        // 检查确认码
        if (confirmCode === 0xff) {
          console.log('✅ 删除指纹成功！');
          
          // 🎯 第一步：先返回结果并清理状态（重要！必须在触发回调之前）
          if (this.pendingDeleteResolve) {
            this.pendingDeleteResolve({ success: true, fingerprintId: responseId });
            this.cleanupDeleteRawDataListener();
            console.log('✅ 已返回删除结果并清理状态');
          }
          
          // 🎯 第二步：再主动触发删除命令回调，阻止重发
          if (this.activeRcspCommands.length > 0) {
            const deleteCmd = this.activeRcspCommands.find(item => 
              item.command && item.command.getParam && 
              item.command.getParam() && 
              item.command.getParam().basePayload && 
              item.command.getParam().basePayload[0] === 0x03
            );
            if (deleteCmd) {
              this.triggerCommandCallback(deleteCmd.command, deleteCmd.device, [responseId]);
              this.removeRcspCommand(deleteCmd.command);
            }
          }
        } else {
          const errorMsg = this.getDeleteErrorMessage(confirmCode);
          console.error('❌ 删除指纹失败，错误码:', '0x' + confirmCode.toString(16).padStart(2, '0'), errorMsg);
          
          if (this.pendingDeleteReject) {
            this.pendingDeleteReject(new Error(`删除失败: ${errorMsg}`));
            this.cleanupDeleteRawDataListener();
          }
        }
      } else {
        console.log('❌ 数据长度不足');
      }
      
      console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━');
      
    } catch (error) {
      console.error('❌ 解析删除指纹原始数据失败:', error);
      if (this.pendingDeleteReject) {
        this.pendingDeleteReject(error);
        this.cleanupDeleteRawDataListener();
      }
    }
  },

  // ArrayBuffer转十六进制
  arrayBufferToHex: function(buffer) {
    const byteArray = new Uint8Array(buffer);
    return Array.from(byteArray)
      .map(b => b.toString(16).padStart(2, '0'))
      .join('');
  },

  // 🎯 解析添加指纹的原始数据
  parseAddRawData: function(hexString) {
    try {
      console.log('━━━━━ 添加指纹原始数据解析 ━━━━━');
      console.log('完整数据:', hexString);
      
      // 查找添加响应模式：fedcbac05a...ef，提取中间所有数据
      const pattern = /fedcbac05a([0-9a-f]+)ef/i;
      const match = hexString.match(pattern);
      
      if (!match || !match[1]) {
        console.log('❌ 未匹配到添加响应模式');
        return;
      }
      
      const allData = match[1];
      console.log('🎯 提取到所有中间数据:', allData);
      
      // 跳过前3字节的底层协议，提取后面的10字节数据
      if (allData.length >= 26) { // 3字节底层协议 + 10字节数据 = 13字节 = 26个字符
        const targetData = allData.substring(6, 26); // 跳过前3字节(6个字符)，取10字节(20个字符)
        console.log('📊 目标10字节数据:', targetData);
        
        // 🎯 先提取步骤号，检查是否已处理过
        const bytes = [];
        for (let i = 0; i < targetData.length; i += 2) {
          bytes.push(parseInt(targetData.substring(i, i + 2), 16));
        }
        const stepIndex = bytes[2]; // bytes[2] 是步骤号
        
        // 🎯 检查该步骤是否已处理过
        if (this.processedAddSteps.has(stepIndex)) {
          console.log(`⚠️ 步骤${stepIndex}已处理过，忽略重复数据`);
          console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━');
          return;
        }
        
        console.log(`✅ 步骤${stepIndex}首次处理，继续...`);
        
        // 解析添加指纹响应数据
        this.parseAddFingerprintResponse(targetData);
      } else {
        console.log('❌ 数据长度不足，无法解析');
      }
      
      console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━');
      
    } catch (error) {
      console.error('❌ 解析添加指纹原始数据失败:', error);
    }
  },

  // 🎯 解析添加指纹响应 02030100000000000000
  parseAddFingerprintResponse: function(dataHex) {
    try {
      console.log('🔍 开始解析添加指纹响应:', dataHex);
      
      // 转换为字节数组
      const bytes = [];
      for (let i = 0; i < dataHex.length; i += 2) {
        bytes.push(parseInt(dataHex.substring(i, i + 2), 16));
      }
      
      console.log('字节数组:', bytes.map(b => '0x' + b.toString(16).padStart(2, '0')).join(' '));
      
      // 数据结构：02030100000000000000
      // bytes[0] = 0x02 (OpCode - 添加命令)
      // bytes[1] = 指纹ID (1-5)
      // bytes[2] = index (1-5) 
      // bytes[3] = 确认码 (0x00=成功，其他=失败)
      // bytes[4-9] = 额外字节
      
      const opCode = bytes[0];
      const fingerprintId = bytes[1];
      const stepIndex = bytes[2];
      const confirmCode = bytes[3];
      
      console.log('OpCode:', '0x' + opCode.toString(16).toUpperCase());
      console.log('指纹ID:', fingerprintId);
      console.log('步骤:', stepIndex);
      console.log('确认码:', '0x' + confirmCode.toString(16).padStart(2, '0'));
      
      // 验证OpCode必须是02
      if (opCode !== 0x02) {
        console.log('❌ OpCode不匹配，期望0x02，实际:', '0x' + opCode.toString(16));
        return;
      }
      
      // 处理添加指纹步骤
      this.handleAddFingerprintStep(fingerprintId, stepIndex, confirmCode);
      
    } catch (error) {
      console.error('❌ 解析添加指纹响应失败:', error);
      this.handleAddError('解析响应失败');
    }
  },

  // 🎯 处理添加指纹步骤
  handleAddFingerprintStep: function(fingerprintId, stepIndex, confirmCode) {
    console.log(`📝 处理添加指纹步骤: ID=${fingerprintId}, 步骤=${stepIndex}, 确认码=0x${confirmCode.toString(16).padStart(2, '0')}`);
    
    // 检查确认码
    if (confirmCode !== 0x00) {
      // 添加失败
      console.error('❌ 添加指纹失败，错误码:', '0x' + confirmCode.toString(16).padStart(2, '0'));
      this.handleAddError(`添加失败，错误码：0x${confirmCode.toString(16).padStart(2, '0').toUpperCase()}`);
      return;
    }
    
    // 🎯 记录已处理的步骤
    this.processedAddSteps.add(stepIndex);
    console.log(`🔖 记录步骤${stepIndex}已处理，当前已处理步骤:`, Array.from(this.processedAddSteps).sort());
    
    // 添加成功，更新进度
    const progressPercent = (stepIndex / 5) * 100;
    const progressTexts = {
      1: '第一步录入中...',
      2: '第二步录入中...',
      3: '第三步录入中...',
      4: '第四步录入中...',
      5: '录入完成！'
    };
    
    this.setData({
      addProgress: stepIndex,
      addProgressPercent: progressPercent,
      addProgressText: progressTexts[stepIndex] || `第${stepIndex}步录入中...`
    });
    
    console.log(`✅ 指纹录入步骤${stepIndex}完成，进度: ${progressPercent}%`);
    
    // 第5步完成，添加成功
    if (stepIndex === 5) {
      console.log('🎉 指纹录入完成！');
      
      // 🎯 主动触发添加命令回调，阻止重发
      if (this.currentAddCommand && this.currentAddDevice) {
        this.triggerCommandCallback(this.currentAddCommand, this.currentAddDevice, [fingerprintId]);
        this.removeRcspCommand(this.currentAddCommand);
        this.currentAddCommand = null;
        this.currentAddDevice = null;
      }
      
      this.setData({
        addStatus: 'success',
        addProgressText: '录入完成',
        isAddingFingerprint: false // 清除添加状态标记
      });
      console.log('🏷️ 清除添加指纹状态标记');
      
      // 清理监听器
      this.cleanupUnifiedRawDataListener();
      
      // ✅ 添加成功后，直接更新本地缓存
      console.log('🔄 指纹添加成功，更新本地缓存...');
      this.updateCacheAfterAdd(fingerprintId);
      
      // 🎯 先保存fingerprintId，因为closeAddModal会清空它
      const completedFingerprintId = fingerprintId;
      
      // 延迟后弹出命名框并关闭弹窗
      setTimeout(() => {
        this.closeAddModal();
        this.showFingerprintNameDialog(completedFingerprintId);
      }, 1500);
    }
  },


  // ✅ 添加成功后更新缓存
  updateCacheAfterAdd: function(fingerprintId) {
    console.log('📝 添加成功后更新缓存，新增指纹ID:', fingerprintId);
    
    // 🎯 直接在本地缓存中添加新ID，不查询（避免超时导致缓存清空）
    const currentCache = this.data.cachedFingerprintList || [];
    const newCache = [...currentCache];
    if (!newCache.includes(fingerprintId)) {
      newCache.push(fingerprintId);
      newCache.sort((a, b) => a - b);
      
      const now = Date.now();
      
      // 🔥 同时更新本地存储
      const cacheKey = `fingerprint_cache_${this.data.deviceId}`;
      wx.setStorageSync(cacheKey, {
        list: newCache,
        timestamp: now
      });
      
      this.setData({
        cachedFingerprintList: newCache,
        lastQueryTime: now // 🎯 更新缓存时间戳，保持缓存有效
      });
      
      console.log('💾 本地添加到缓存并保存到存储:', newCache);
      
      // 更新UI显示
      const users = this.parseFingerprintUsers(newCache);
      this.setData({ users: users });
      console.log('✅ UI已更新显示新指纹');
    }
  },

  // ✅ 删除成功后更新缓存（不查询，直接从缓存中移除）
  updateCacheAfterDelete: function(fingerprintId) {
    console.log('🗑️ 删除成功后更新缓存，移除指纹ID:', fingerprintId);
    
    // 从缓存中移除指定ID
    const currentCache = this.data.cachedFingerprintList || [];
    const newCache = currentCache.filter(id => id !== fingerprintId);
    
    const now = Date.now();
    
    // 🔥 同时更新本地存储
    const cacheKey = `fingerprint_cache_${this.data.deviceId}`;
    wx.setStorageSync(cacheKey, {
      list: newCache,
      timestamp: now
    });
    
    this.setData({
      cachedFingerprintList: newCache,
      lastQueryTime: now // 🎯 更新缓存时间戳，保持缓存有效
    });
    
    console.log('💾 缓存已更新（删除）并保存到存储:', newCache);
  },

  // 🎯 解析查询指纹的原始数据
  parseQueryRawData: function(hexString) {
    try {
      console.log('━━━━━ 查询指纹原始数据解析 ━━━━━');
      console.log('完整数据:', hexString);
      
      // 🎯 防止重复处理：检查是否在2秒内已经处理过
      const now = Date.now();
      if (now - this.lastQueryResponseTime < 2000) {
        console.log('⚠️ 2秒内已处理过查询响应，忽略重复数据');
        console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━');
        return;
      }
      
           // 查找查询响应模式：fedcbac05a...ef，提取中间所有数据
           const pattern = /fedcbac05a([0-9a-f]+)ef/i;
           const match = hexString.match(pattern);
           
           if (!match || !match[1]) {
             console.log('❌ 未匹配到查询响应模式');
             return;
           }
           
           const allData = match[1];
           console.log('🎯 提取到所有中间数据:', allData);
           
           // 跳过前3字节的底层协议(000b2a)，提取后面的10字节数据
           if (allData.length >= 26) { // 3字节底层协议 + 10字节数据 = 13字节 = 26个字符
             const targetData = allData.substring(6, 26); // 跳过前3字节(6个字符)，取10字节(20个字符)
             console.log('📊 目标10字节数据:', targetData);
        
        // 解析10字节数据
        const occupiedIds = this.parse10ByteData(targetData);
        
        console.log('✅ 解析得到指纹ID列表:', occupiedIds);
        
        // 🎯 记录处理时间戳，防止2秒内重复处理
        this.lastQueryResponseTime = now;
        console.log('⏰ 已记录查询响应处理时间戳');
        
        // 🎯 第一步：先返回结果并清理状态（重要！必须在触发回调之前）
        if (this.pendingQueryResolve) {
          this.pendingQueryResolve(occupiedIds);
          this.clearPendingQuery();
          console.log('✅ 已返回结果并清理查询状态');
        }
        
        // 🎯 第二步：再触发命令回调，告诉RCSP命令已完成（阻止重发）
        this.triggerCommandCallback(this.currentRcspCommand, this.currentRcspDevice, occupiedIds);
        
        // 🎯 第三步：移除已完成的查询命令
        if (this.currentRcspCommand) {
          this.removeRcspCommand(this.currentRcspCommand);
        }
      } else {
        console.log('❌ 数据长度不足，无法解析');
        if (this.pendingQueryResolve) {
          this.pendingQueryResolve([]);
          this.clearPendingQuery();
        }
      }
      
      console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━');
      
    } catch (error) {
      console.error('❌ 解析查询指纹原始数据失败:', error);
      if (this.pendingQueryReject) {
        this.pendingQueryReject(error);
        this.clearPendingQuery();
      }
    }
  },

  // 🎯 解析10字节数据 01010000000400000000
  parse10ByteData: function(dataHex) {
    const occupiedIds = [];
    
    try {
      console.log('🔍 开始解析10字节数据:', dataHex);
      
      // 转换为字节数组
      const bytes = [];
      for (let i = 0; i < dataHex.length; i += 2) {
        bytes.push(parseInt(dataHex.substring(i, i + 2), 16));
      }
      
      console.log('字节数组:', bytes.map(b => '0x' + b.toString(16).padStart(2, '0')).join(' '));
      
           // 数据结构：01020100000400000000
           // bytes[0] = 0x01 (OpCode - 查询命令)
           // bytes[1] = 0x02 (指纹数量)
           // bytes[2-6] = 5个槽位的指纹ID（0=空，1-5=指纹ID）
           // bytes[7-9] = 额外3字节
           
           const opCode = bytes[0];
           const count = bytes[1];
           
           console.log('OpCode:', '0x' + opCode.toString(16).toUpperCase());
           console.log('指纹数量:', count);
           
           // 只扫描槽位数据（bytes[2-6]，共5个槽位）
           for (let i = 2; i <= 6 && i < bytes.length; i++) {
             const value = bytes[i];
             console.log(`槽位[${i-2+1}]:`, '0x' + value.toString(16).padStart(2, '0'), value === 0 ? '(空槽位)' : `→ 指纹ID ${value}`);
             
             // 只取1-5范围内的值作为指纹ID
             if (value >= 1 && value <= 5) {
               if (!occupiedIds.includes(value)) {
                 occupiedIds.push(value);
                 console.log(`✓ 找到指纹ID: ${value}`);
               }
             }
           }
           
           // 显示额外字节（仅用于调试）
           if (bytes.length > 7) {
             console.log('额外字节:', bytes.slice(7).map(b => '0x' + b.toString(16).padStart(2, '0')).join(' '));
           }
      
      console.log('🎯 最终指纹ID列表:', occupiedIds);
      
    } catch (error) {
      console.error('❌ 解析10字节数据失败:', error);
    }
    
    return occupiedIds;
  },

  // 🎯 清理查询pending状态
  clearPendingQuery: function() {
    console.log('🧹 清理查询pending状态');
    
    // 恢复原始监听器
    this.cleanupUnifiedRawDataListener();
    
    // 清理pending状态
    this.pendingQueryResolve = null;
    this.pendingQueryReject = null;
    
    // 清理命令引用
    this.currentRcspCommand = null;
    this.currentRcspDevice = null;
  },

  // 🚫 取消RCSP命令，阻止重发
  cancelRcspCommand: function() {
    try {
      if (this.currentRcspCommand && this.currentRcspDevice) {
        console.log('🚫 尝试取消RCSP命令重发机制...');
        
        const rcspWrapper = this.getRcspWrapper();
        const actualWrapper = rcspWrapper.wrapper;
        const rcspOpImpl = actualWrapper._rcspOpImpl;
        
        if (rcspOpImpl && rcspOpImpl.cancelRCSPCommand) {
          // 尝试调用取消方法（如果存在）
          rcspOpImpl.cancelRCSPCommand(this.currentRcspDevice, this.currentRcspCommand);
          console.log('✅ 已调用取消命令方法');
        } else if (this.currentRcspCommand.cancel) {
          // 或者直接调用命令对象的取消方法
          this.currentRcspCommand.cancel();
          console.log('✅ 已调用命令对象取消方法');
        } else {
          console.log('⚠️ 未找到取消命令的方法，RCSP可能继续重发');
        }
        
        // 清理引用
        this.currentRcspCommand = null;
        this.currentRcspDevice = null;
      }
    } catch (error) {
      console.error('❌ 取消RCSP命令失败:', error);
      // 失败不影响功能，忽略
    }
  },

  // 🎯 跟踪活跃的RCSP命令
  trackRcspCommand: function(device, command) {
    this.activeRcspCommands.push({ device, command });
    console.log('📌 已跟踪RCSP命令，当前活跃命令数:', this.activeRcspCommands.length);
  },

  // 🎯 移除已完成的RCSP命令
  removeRcspCommand: function(command) {
    const index = this.activeRcspCommands.findIndex(item => item.command === command);
    if (index !== -1) {
      this.activeRcspCommands.splice(index, 1);
      console.log('✅ 已移除完成的RCSP命令，当前活跃命令数:', this.activeRcspCommands.length);
    }
  },

  // 🎯 主动触发命令回调，让RCSP认为已收到响应（阻止重发）
  triggerCommandCallback: function(command, device, data) {
    try {
      if (!command) {
        console.log('⚠️ 命令对象为空，无法触发回调');
        return;
      }
      
      console.log('🎭 尝试主动触发命令回调，阻止RCSP重发...');
      console.log('命令对象:', command);
      console.log('命令类型:', command.constructor ? command.constructor.name : 'unknown');
      
      // 创建假的响应对象
      const fakeResponse = {
        getPayload: () => {
          // 返回合理的数据
          if (Array.isArray(data)) {
            return new Uint8Array(data);
          }
          return new Uint8Array([0x01]); // 默认返回成功
        },
        getData: () => {
          if (Array.isArray(data)) {
            return new Uint8Array(data);
          }
          return new Uint8Array([0x01]);
        }
      };
      
      // 尝试设置响应
      if (command.setResponse) {
        command.setResponse(fakeResponse);
        console.log('✅ 已调用 setResponse');
      }
      
      // 尝试直接设置内部属性
      command._response = fakeResponse;
      command._isCompleted = true;
      command._hasResponse = true;
      console.log('✅ 已设置内部属性');
      
      // 🔥 关键：查找并调用原始的命令回调
      if (this._commandCallbacks && this._commandCallbacks.has(command)) {
        const callback = this._commandCallbacks.get(command);
        if (callback && callback.onCmdResponse) {
          console.log('🔥 找到命令回调，主动触发...');
          try {
            callback.onCmdResponse(device, command);
            console.log('✅ 已触发 onCmdResponse 回调');
          } catch (err) {
            console.error('❌ 触发回调失败:', err);
          }
        }
      }
      
      console.log('🎭 命令回调触发完成');
      
    } catch (error) {
      console.error('❌ 触发命令回调失败:', error);
    }
  },

  // 🎯 强制清空 RCSP SDK 的发送队列（防止页面卸载后继续重发）
  forceCleanRcspQueue: function() {
    try {
      const rcspWrapper = this.getRcspWrapper();
      if (!rcspWrapper || !rcspWrapper.wrapper) {
        console.log('⚠️ RCSP包装器不可用');
        return;
      }
      
      const actualWrapper = rcspWrapper.wrapper;
      const rcspOpImpl = actualWrapper._rcspOpImpl;
      
      if (!rcspOpImpl) {
        console.log('⚠️ RCSP操作实例不可用');
        return;
      }

      // 🔥 关键：访问 RCSP SDK 的内部数据处理器（注意是 mRCSPDataHandler）
      const rcspDataHandler = rcspOpImpl.mRCSPDataHandler;
      if (rcspDataHandler) {
        console.log('🎯 找到 RCSPDataHandler，尝试清空发送队列...');
        
        // 清空发送信息数组（待发送/重发的命令）
        if (rcspDataHandler.sendInfoArray) {
          const queueLength = rcspDataHandler.sendInfoArray.length;
          rcspDataHandler.sendInfoArray.length = 0; // 清空数组
          console.log(`✅ 已清空发送队列，原有 ${queueLength} 个待发送命令`);
        }
        
        // 清空超时定时器映射
        if (rcspDataHandler.sendTimeOutIDMap) {
          const timerCount = rcspDataHandler.sendTimeOutIDMap.size || 0;
          
          // 清除所有定时器
          if (rcspDataHandler.sendTimeOutIDMap instanceof Map) {
            rcspDataHandler.sendTimeOutIDMap.forEach((timerId) => {
              try {
                clearTimeout(timerId);
              } catch (err) {
                // 忽略清除失败
              }
            });
            rcspDataHandler.sendTimeOutIDMap.clear();
          } else if (typeof rcspDataHandler.sendTimeOutIDMap === 'object') {
            // 如果是普通对象
            Object.keys(rcspDataHandler.sendTimeOutIDMap).forEach(key => {
              try {
                clearTimeout(rcspDataHandler.sendTimeOutIDMap[key]);
                delete rcspDataHandler.sendTimeOutIDMap[key];
              } catch (err) {
                // 忽略清除失败
              }
            });
          }
          
          console.log(`✅ 已清理 ${timerCount} 个超时定时器`);
        }
        
        console.log('✅ RCSP SDK 发送队列已强制清空');
      } else {
        console.log('⚠️ 未找到 RCSPDataHandler');
      }
      
    } catch (error) {
      console.error('❌ 强制清空 RCSP 队列失败:', error);
    }
  },

  // 🎯 清理所有活跃的RCSP命令
  cleanupAllRcspCommands: function() {
    try {
      if (this.activeRcspCommands.length === 0) {
        console.log('✅ 无活跃的RCSP命令需要清理');
        return;
      }

      console.log('🧹 开始清理', this.activeRcspCommands.length, '个活跃的RCSP命令...');
      
      const rcspWrapper = this.getRcspWrapper();
      const actualWrapper = rcspWrapper.wrapper;
      const rcspOpImpl = actualWrapper._rcspOpImpl;
      
      if (!rcspOpImpl) {
        console.log('⚠️ RCSP操作实例不可用，无法清理命令');
        this.activeRcspCommands = [];
        return;
      }

      // 主动触发所有命令的回调，然后尝试取消
      this.activeRcspCommands.forEach((item, index) => {
        try {
          console.log(`🚫 [${index + 1}/${this.activeRcspCommands.length}] 触发回调并取消命令...`);
          
          // 🎯 先主动触发回调（最重要！）
          this.triggerCommandCallback(item.command, item.device, null);
          
          // 尝试多种取消方式
          if (rcspOpImpl.cancelRCSPCommand) {
            rcspOpImpl.cancelRCSPCommand(item.device, item.command);
          } else if (item.command.cancel) {
            item.command.cancel();
          } else if (item.command.stop) {
            item.command.stop();
          }
        } catch (err) {
          console.error(`❌ 处理命令[${index + 1}]失败:`, err);
        }
      });

      // 清空队列
      this.activeRcspCommands = [];
      console.log('✅ 所有活跃的RCSP命令已清理');

    } catch (error) {
      console.error('❌ 清理RCSP命令失败:', error);
      // 强制清空队列
      this.activeRcspCommands = [];
    }
  },

  // 🎯 解析RCSP载荷作为备用
  parseRcspPayload: function(payload) {
    const occupiedIds = [];
    
    try {
      console.log('🔄 使用RCSP载荷作为备用解析');
      console.log('载荷数据:', Array.from(payload).map(b => '0x' + b.toString(16).padStart(2, '0')).join(' '));
      
      // 扫描载荷中1-5范围的值
      for (let i = 0; i < payload.length; i++) {
        const value = payload[i];
        if (value >= 1 && value <= 5 && !occupiedIds.includes(value)) {
          occupiedIds.push(value);
          console.log(`✓ 备用方法找到指纹ID: ${value}`);
        }
      }
      
    } catch (error) {
      console.error('❌ 解析RCSP载荷失败:', error);
    }
    
    return occupiedIds;
  },


  // 处理添加错误
  handleAddError: function(errorMsg) {
    // 🎯 主动触发失败回调，阻止重发
    if (this.currentAddCommand && this.currentAddDevice) {
      this.triggerCommandCallback(this.currentAddCommand, this.currentAddDevice, null);
      this.removeRcspCommand(this.currentAddCommand);
      this.currentAddCommand = null;
      this.currentAddDevice = null;
    }
    
    // 🎯 发送取消添加指纹命令（失败时通知设备）
    console.log('⚠️ 添加指纹失败，发送取消命令');
    this.sendCancelAddFingerprintCommand();
    
    // 🎯 强制清空 RCSP 队列，防止继续重发
    console.log('🧹 失败后强制清空 RCSP SDK 发送队列');
    this.forceCleanRcspQueue();
    
    this.setData({
      addStatus: 'error',
      addProgressText: '录入失败',
      addErrorMsg: errorMsg,
      isAddingFingerprint: false // 清除添加状态标记
    });
    console.log('🏷️ 清除添加指纹状态标记（失败）');
    
    // 🎯 清空已处理步骤记录
    this.processedAddSteps.clear();
    console.log('🧹 失败后清空已处理步骤记录');
    
    // 清理监听器
    this.cleanupUnifiedRawDataListener();
  },

  // 获取添加指纹错误信息
  getErrorMessage: function(confirmCode) {
    const errorMessages = {
      0x00: '成功',
      0x01: '收包有错',
      0x0b: 'pageid超出范围',
      0x18: '写flash出错',
      0x31: '功能与加密等级不匹配',
      0x35: '非法数据'
    };
    
    return errorMessages[confirmCode] || '未知错误';
  },

  // 获取删除指纹错误信息
  getDeleteErrorMessage: function(confirmCode) {
    const errorMessages = {
      0xff: '成功',
      0x01: '收包有错',
      0x10: '模组删除模版失败',
      0x02: '本地存储模版不存在',
      0x20: '本地存储模版写入错误'
    };
    
    return errorMessages[confirmCode] || `未知错误(0x${confirmCode.toString(16).padStart(2, '0').toUpperCase()})`;
  },

  // 显示指纹命名对话框
  showFingerprintNameDialog: function(fingerprintId) {
    console.log('📝 显示命名对话框，指纹ID:', fingerprintId);
    
    const fingerIdStr = `F${String(fingerprintId).padStart(3, '0')}`;
    const defaultName = `指纹用户${fingerprintId}`;
    
    wx.showModal({
      title: '命名指纹',
      content: '例如：妈妈',
      editable: true,
      placeholderText: defaultName,
      success: (res) => {
        let finalName = defaultName;
        
        if (res.confirm) {
          // 用户点击确认
          if (res.content && res.content.trim()) {
            // 有输入内容，使用输入的名称
            finalName = res.content.trim();
            console.log('✅ 用户输入名称:', finalName);
          } else {
            // 没有输入，使用默认名称
            console.log('⚠️ 用户未输入，使用默认名称:', finalName);
          }
        } else {
          // 用户取消，使用默认名称
          console.log('⚠️ 用户取消命名，使用默认名称:', finalName);
        }
        
        // 保存指纹用户名称
        this.saveUserName(fingerIdStr, finalName);
        
        // 🎯 更新UI显示的名称（UI列表已经添加了，只需要更新名称）
        const updatedUsers = this.data.users.map(user => {
          if (user.id === fingerprintId) {
            return { ...user, name: finalName };
          }
          return user;
        });
        
        this.setData({ users: updatedUsers });
        console.log('✅ UI已更新显示新名称');
        
        wx.showToast({
          title: '指纹添加成功',
          icon: 'success'
        });
      }
    });
  },

  // 保存指纹用户名称
  saveUserName: function(fingerId, name) {
    try {
      const savedNames = wx.getStorageSync('fingerprintUserNames') || {};
      savedNames[fingerId] = name;
      wx.setStorageSync('fingerprintUserNames', savedNames);
      console.log(`✅ 成功保存指纹用户名称: ${fingerId} => ${name}`);
    } catch (error) {
      console.error('❌ 保存指纹用户名称失败:', error);
    }
  },

  // ========== 删除指纹 ==========
  
  // 删除指纹用户
  deleteUser: function(e) {
    const userId = e.currentTarget.dataset.id;
    const user = this.data.users.find(u => u.id === userId);
    
    if (!this.checkDeviceConnection()) {
      return;
    }
    
    wx.showModal({
      title: '删除指纹',
      content: `确定要删除"${user?.name}"吗？`,
      success: (res) => {
        if (res.confirm) {
          this.showLoading('正在唤醒设备...');
          
          // 先发送唤醒指令，1秒后再发送删除命令
          console.log('⏰ 删除前发送唤醒指令...');
          this.sendWakeUpCommand()
            .then(() => {
              console.log('⏳ 等待1秒后发送删除命令...');
              this.showLoading('正在删除...');
              return new Promise(resolve => setTimeout(resolve, 1000));
            })
            .then(() => {
              console.log('✅ 唤醒完成，发送删除命令');
              // 发送删除指纹命令
              return this.sendFingerprintDeleteCommand(userId);
            })
            .then(result => {
              console.log('✅ 删除指纹成功:', result);
              
              // ✅ 从缓存中移除
              this.updateCacheAfterDelete(userId);
              
              // 从列表中移除用户
              const newUsers = this.data.users.filter(u => u.id !== userId);
              this.setData({ users: newUsers });
              
              this.hideLoading();
              
              wx.showToast({
                title: '删除成功',
                icon: 'success'
              });
            })
            .catch(error => {
              console.error('❌ 删除指纹流程失败:', error);
              this.hideLoading();
              
              // ❌ 命令失败，不更新缓存，不删除UI
              // 显示详细错误信息
              const errorMsg = error.message || '删除失败，请重试';
              wx.showToast({
                title: errorMsg.length > 20 ? '删除失败，请重试' : errorMsg,
                icon: 'none',
                duration: 2000
              });
            });
        }
      }
    });
  },

  // 发送删除指纹命令
  sendFingerprintDeleteCommand: function(fingerprintId) {
    return new Promise((resolve, reject) => {
      try {
        const rcspWrapper = this.getRcspWrapper();
        const actualWrapper = rcspWrapper.wrapper;
        const rcspOpImpl = actualWrapper._rcspOpImpl;
        
        if (!rcspOpImpl) {
          reject(new Error('RCSP操作实例不可用'));
          return;
        }

        const currentDevice = rcspOpImpl.getUsingDevice();
        if (!currentDevice) {
          reject(new Error('当前没有使用的设备'));
          return;
        }

        // 🎯 设置删除专用的原始数据监听器
        this.setupDeleteRawDataListener(fingerprintId, resolve, reject);

        // 创建删除参数类
        class DeleteParam extends ParamBase {
          constructor(fingerprintId) {
            super();
            this.basePayload = new Uint8Array([0x03, fingerprintId]);
            // 0x03 = 删除操作
          }
          
          toData() {
            return this.basePayload;
          }
          
          parseData(data) {
            this.basePayload = data;
            return data.length;
          }
        }

        const param = new DeleteParam(fingerprintId);
        const command = new CmdCustom(param);
        command.setOpCode(0x5A);
        
        // 🎯 跟踪命令
        this.trackRcspCommand(currentDevice, command);
        
        const commandCallback = {
          onCmdResponse: (device, cmd) => {
            console.log('✅ 删除指纹命令响应（备用）');
            // 🎯 移除已完成的命令
            this.removeRcspCommand(command);
            // 原始数据监听器会优先处理，这里作为备用
          },
          onError: (device, code, message) => {
            console.error('❌ 删除指纹RCSP命令超时:', code, message);
            // 🎯 移除失败的命令
            this.removeRcspCommand(command);
            // 如果原始数据监听器已经处理了，忽略超时错误
            console.log('💡 可能原始数据监听器已处理删除响应');
          }
        };

        // 🎯 保存命令回调到映射表
        this._commandCallbacks.set(command, commandCallback);
        console.log('📌 已保存删除命令回调到映射表');

        rcspOpImpl.sendRCSPCommand(
          currentDevice,
          command,
          5000,
          commandCallback
        );

        console.log(`📤 已发送删除指纹命令，标号: ${fingerprintId}`);

        // 设置总超时（比RCSP超时稍长）
        setTimeout(() => {
          if (this.pendingDeleteResolve) {
            console.log('⏰ 删除指纹总超时');
            this.cleanupDeleteRawDataListener();
            reject(new Error('删除超时'));
          }
        }, 6000);

      } catch (error) {
        console.error('❌ 发送删除命令异常:', error);
        this.cleanupDeleteRawDataListener();
        reject(error);
      }
    });
  },

  // ========== 重命名指纹 ==========
  
  // 重命名指纹用户
  renameUser: function(e) {
    const userId = e.currentTarget.dataset.id;
    const user = this.data.users.find(u => u.id === userId);
    
    if (user) {
      wx.showModal({
        title: '重命名指纹',
        content: '例如：妈妈',
        editable: true,
        placeholderText: user.name,
        success: (res) => {
          if (res.confirm) {
            const newName = res.content.trim();
            if (newName) {
              this.showLoading('正在重命名...');
              
              // 保存新的用户名称
              this.saveUserName(user.fingerId, newName);
              
              // 更新UI
              setTimeout(() => {
                const newUsers = this.data.users.map(u => {
                  if (u.id === userId) {
                    return { ...u, name: newName };
                  }
                  return u;
                });
                
                this.setData({ users: newUsers });
                this.hideLoading();
                
                wx.showToast({
                  title: '重命名成功',
                  icon: 'success'
                });
              }, 500);
            } else {
              wx.showToast({
                title: '名称不能为空',
                icon: 'none'
              });
            }
          }
        }
      });
    }
  },

  // ========== 辅助方法 ==========
  
  // 显示全局加载中状态
  showLoading: function(text) {
    this.setData({
      isLoading: true,
      loadingText: text || '处理中...'
    });
  },
  
  // 隐藏全局加载状态
  hideLoading: function() {
    this.setData({
      isLoading: false,
      loadingText: ''
    });
  }
});
